Solving a Real-life Time Tabling and Transportation Problem

Many real-life problems in the domain of resource allocation and scheduling require Solutions which are composed of several approaches or techniques. Often, complex problems are divided into sub-problems, subproblems are solved by separate people (agents), who may use different techniques and expertise for solving them, and the sub-problems are combined later to yield a coherent, consistent solution. This last phase may involve negotiations with the various agents and requests for changes in their own solutions. A real-life example of the above problem is presented in this paper. The problem is the construction of a weekly timetable of nurses in several departments in a large Israeli hospital, and based on the departmental timetables, the construction of a transportation plan for all the nurses. This transportation plan tries to minimize the cost of transportation regardless of the departmental assignments; i.e., the number of vehicles sent and the distances they cover should be (approximately) minimal. It may happen that the agent responsible for transportation may ask for changes in the individual timetables, to avoid situations such as assigning a vehicle to bring in a single nurse from a far-away place. Obviously, this problem is a real-life instance of the distributed resource allocation problems. The hospital requires that its departments maintain local control on the assignment of nurses; this ruled out the option of using a centralized algorithm to solve the whole problem. One alternative was to use a synchronized distributed algorithm (i.e., implementing a standard CSP’ algorithm, in a distributed environment). In (Solotorevsky & Gudes 1996) we show that synchronized distributed algorithms are quite ineffective for performance, since this approach requires sending numerous messages, which slows the solution process. Moreover combining local control in a synchronized distributed algorithm is unnatural. Another alternative was to use asynchronous algorithms as the ones developed by Yokoo (Yokoo et al. 1992; Yokoo 1995) however these algorithms assume that each agent manages only one variable. It is possible to extend these algorithms to situations where each agent manages an entire sub-problem (e.g., a department of a hospital), however such extension poses many obstacles due to the non homogeneous difficulty of the sub-problems, and may greatly damage the overall performance of the system. In (Solotorevsky & Gudes 1996) we developed an approach to solve DCSPs (Distributed Constraint Satisfaction Problems) which was specially designed for situations in which each agent handles a complete sub problem, as opposite to a single variable. Furthermore, our approach takes advantage of the differences between the difficulties of the sub-problems. Our approach is based on a forward searching stage that is completely asynchronous and a backtracking stage that is semi-asynchronous. That is, the backtracking itself is done synchronously, but in the stages where the backtracking takes place all the agents which are not actively participating in the backtracking process, work asynchronously in searching for alternative solutions, solutions that will be available when the backtracking stage ends (for work on distributed scheduling not based on the CSP paradigm see (Sycara et al. 1991) and (Neiman & Lesser 1996)). In (Solotorevsky & Gudes 1996) we tested our algorithms for solving DCSPs on random DCSPs with varying characteristics. In this paper we show how to apply and extend these algorithms to the nurses’ timetabling and transportation problem (NTTT). In the next section we describe in detail the nurses problem. In the third section the original algorithms are described and in the fourth section they are extended for the problem in hand. It should be noted that our problem is a real problem which is currently being solved partly by a knowledge-based program and partly by human experts. The last section discusses the suitability of our DCSP algorithms to this situation and compares their behavior to sequential algorithms.